home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1997 April / EnigmA AMIGA RUN 17 (1997)(G.R. Edizioni)(IT)[!][issue 1997-04][EAR-CD].iso / EARCD / comm / bbs / citsrc6K05.lha / datachng.c < prev    next >
C/C++ Source or Header  |  1996-10-13  |  15KB  |  630 lines
  1. /*
  2. *                               Datachng.c
  3. *
  4. * Data expander and shrinker for C-86.
  5. */
  6. /*
  7. *                               history
  8. *
  9. * 89Apr13 HAW  Fix problem with expanding shared rooms (V1.3)
  10. * 87Nov30 HAW  Fix problem with expanding rooms (V1.2)
  11. * 87Nov?? HAW  Fix problem with reducing Mail.
  12. * 87Oct12 HAW  Modified from Lexpand.
  13. * 85Nov16 HAW  Modified for MS-DOS libraries.
  14. * 85May23 HAW  Created.
  15. */
  16. #include "ctdl.h"    /* header file  */
  17. #include <stdio.h>
  18. #include <string.h>
  19. #include <stdlib.h>
  20. #include <math.h>
  21. #include <ctype.h>
  22. #include <time.h>
  23. #include <proto/exec.h>
  24. #include <dos/dos.h>
  25. #include <pragmas/dos_pragmas.h>
  26. #include "exec/memory.h"
  27. #include "exec/ports.h"
  28. #include "exec/exec.h"
  29. /*
  30. *                               Contents
  31. *
  32. *       crashout()              irrecoverable error
  33. *       getUtilNumber()         prompt user for a number, limited range
  34. *       init()                  initialization
  35. *       main()                  main controller
  36. *       openFile()              opens a .sys file
  37. */
  38. #define DoFree(p)       if ((p) != NULL)  {  free(p);  }
  39. extern CONFIG    cfg;
  40. extern LogTable  *logTab;       /* RAM index of pippuls */
  41. extern logBuffer logBuf;        /* Pippul buffer        */
  42. extern aRoom     roomBuf;
  43. extern NetBuffer netBuf;
  44. extern rTable    *roomTab;
  45. extern NetTable  *netTab;
  46. extern FILE      *logfl;        /* log file descriptor  */
  47. extern FILE      *roomfl;
  48. extern FILE      *netfl;
  49. #ifdef ANSI_PROTOTYPING
  50. int  getUtilNumber(char *prompt, unsigned bottom, unsigned top);
  51. void getUtilString(char *prompt, char *buf, int lim);
  52. void init(void);
  53. void menus(void);
  54. void LogExpand(void);
  55. void RoomHandler(void);
  56. void LogGenChange(int NewSize);
  57. void MsgHandler(void);
  58. void remakeRoomFl(void);
  59. void remakeLogFl(void);
  60. void remakeNetFl(void);
  61. void MailHandler(void);
  62. int  NEUtilGetch(void);
  63. int  UtilGetch(void);
  64. void SharedHandler(void);
  65. void NetArchHandler(void);
  66. char getUYesNo(char *prompt);
  67. #endif
  68.  
  69. int  mPrintf(char *format, ...) {return 0; }  /* stub to quiet the linker */
  70.  
  71. /*
  72. * crashout()
  73. *
  74. * This handles the irrecoverable error.
  75. */
  76. void crashout(str)
  77. char *str;
  78.   {
  79.   exit(printf(str));
  80.  
  81.   }
  82. /*
  83. * getUtilNumber()
  84. *
  85. * This function prompts for a number in (bottom, top) range.
  86. */
  87. int getUtilNumber(prompt, bottom, top)
  88. char   *prompt;
  89. unsigned bottom;
  90. unsigned top;
  91.   {
  92.   int try;
  93.   char numstring[NAMESIZE];
  94.   do
  95.     {
  96.     getUtilString(prompt, numstring, NAMESIZE);
  97.     try     = atoi(numstring);
  98.     if (try < bottom)  printf("Sorry, must be at least %d\n", bottom);
  99.     if (try > top   )  printf("Sorry, must be no more than %d\n", top);
  100.  
  101.     }
  102.   while (try < bottom ||  try > top);
  103.   return  try;
  104.  
  105.   }
  106. /*
  107. * getUtilString()
  108. *
  109. * This function gets a string from the user.
  110. */
  111. void getUtilString(prompt, buf, lim)
  112. char *prompt;
  113. char *buf;
  114. int  lim;       /* max # chars to read */
  115.   {
  116.   char c;
  117.   int  i;
  118.   if(strLen(prompt) > 0)
  119.     {
  120.     printf("\nEnter %s : ", prompt, lim);
  121.  
  122.     };
  123.   i   = 0;
  124.   while (       (c = getchar()) !='\n' && i < lim )
  125.     {
  126.     buf[i++] = c;
  127.     };
  128.   buf[i]  = '\0';
  129.   if( i == lim )while ( getchar() != '\n');
  130.   putchar('\n');
  131.  
  132.   }
  133. /*
  134. * getUYesNo()
  135. *
  136. * This handles a yes/no question.
  137. */
  138. char getUYesNo(prompt)
  139. char *prompt;
  140.   {
  141.   int  toReturn = ERROR;
  142.   char c;
  143.   do
  144.     {
  145.     printf("\n%s? (Y/N)", prompt);
  146.     c = getchar();
  147.     while( getchar() != '\n');
  148.     switch ( toUpper(c) )
  149.       {
  150.       case 'Y': toReturn = TRUE; break;
  151.       case 'N': toReturn = FALSE; break;
  152.       default: printf("You must answer Yes or No\n");
  153.       }
  154.     }
  155.   while (toReturn == ERROR);
  156.   return (char)toReturn;
  157.  
  158.   }
  159. /*
  160. * init()
  161. *
  162. * This handles initializization details.
  163. */
  164. void init()
  165.   {
  166.   SYS_FILE tempname;
  167.   cfg.weAre = UTILITY;
  168.   if (!readSysTab(FALSE, TRUE)) exit(1);  /* No system table? Tacky, tacky*/
  169.   if (access(LOCKFILE, 0) != -1)
  170.     {
  171.     printf("Please do not run DataChng using Outside Commands.\n");
  172.     exit(1);
  173.  
  174.     }
  175.   mvToHomeDisk(&cfg.homeArea);
  176.   makeSysName(tempname, "ctdllog.sys", &cfg.logArea);
  177.   openFile(tempname,  &logfl );
  178.   makeSysName(tempname, "ctdlroom.sys", &cfg.roomArea);
  179.   openFile(tempname,  &roomfl );
  180.   if (cfg.BoolFlags.netParticipant)
  181.     {
  182.     makeSysName(tempname, "ctdlnet.sys", &cfg.netArea);
  183.     openFile(tempname,  &netfl );
  184.     initNetBuf(&netBuf);
  185.  
  186.     }
  187.   initLogBuf(&logBuf);
  188.   initRoomBuf(&roomBuf);
  189.  
  190.   }
  191. /*
  192. * main()
  193. *
  194. * This is the main controller.
  195. */
  196. int main(void);
  197. int main()
  198.   {
  199.   printf("Citadel Data File Expand/Reduce %s\n%s\n", VERSION_NAME,COPYRIGHT);
  200.   init();
  201.   menus();
  202.   return 0;
  203.   }
  204. /*
  205. * menus()
  206. *
  207. * Menu stuff.
  208. */
  209. void menus()
  210.   {
  211.   char c;
  212.   char done = FALSE;
  213.   if (!getUYesNo("HAVE YOU BACKED UP YOUR SYSTEM YET")) crashout("THEN DO SO FIRST!");
  214.   do
  215.     {
  216.     printf("\n\n\n%20c Citadel Data Changer %s\n\n", ' ', VERSION_NAME);
  217.     printf("a) Expand log (presently %d accounts)\n", cfg.MAXLOGTAB);
  218.     printf("b) Expand or contract room table (presently %d slots)\n", MAXROOMS);
  219.     printf("c) Expand or contract the number of messages per room ");
  220.     printf("(presently %d slots)\n", MSGSPERRM);
  221.     printf("d) Expand or contract the number of Mail messages per user ");
  222.     printf("(presently %d slots)\n", MAILSLOTS);
  223.     if (cfg.BoolFlags.netParticipant)
  224.       {
  225.       printf("e) Expand or contract the number of shared rooms/system ");
  226.       printf("(presently %d rooms)\n", SHARED_ROOMS);
  227.  
  228.       }
  229.     c = getchar();
  230.     while( getchar() != '\n');
  231.     switch (toUpper(c))
  232.       {
  233.       case 'A': LogExpand();    break;
  234.       case 'B': RoomHandler();  break;
  235.       case 'C': MsgHandler();     break;
  236.       case 'D': MailHandler();  break;
  237.       case 'E': if (cfg.BoolFlags.netParticipant)
  238.         {
  239.         SharedHandler();        break;
  240.  
  241.         }
  242.       default: done = TRUE;             break;
  243.  
  244.       }
  245.     if (!done) writeSysTab();
  246.  
  247.     }
  248.   while (!done);
  249.  
  250.   }
  251. /*
  252. * LogExpand()
  253. *
  254. * This function handles expanding the user log.
  255. */
  256. void LogExpand()
  257.   {
  258.   int i, j;
  259.   printf("Current log size is %d\n", cfg.MAXLOGTAB);
  260.   i = getUtilNumber("New size", cfg.MAXLOGTAB, 65535);
  261.   if (i > cfg.MAXLOGTAB)
  262.     {
  263.     logTab = (LogTable *) realloc(logTab, sizeof(*logTab) * i);
  264.     logBuf.lbname[0]      = 0;
  265.     logBuf.lbpw[0]      = 0;
  266.     logBuf.lbflags.L_INUSE = FALSE;
  267.     for (j = cfg.MAXLOGTAB; j < i; j++)
  268.       {
  269.       putLog(&logBuf, j);
  270.       logTab[j].ltpwhash  = 0;
  271.       logTab[j].ltnmhash  = 0;
  272.       logTab[j].ltlogSlot = j;
  273.       printf("Clearing %d\r", j);
  274.  
  275.       }
  276.     cfg.MAXLOGTAB = i;
  277.  
  278.     }
  279.   printf("Don't forget to update LOGSIZE in CTDLCNFG.SYS with %d!\n",
  280.   cfg.MAXLOGTAB);
  281.  
  282.   }
  283. /*
  284. * RoomHandler()
  285. *
  286. * This handles the expansion or contraction of the room file.
  287. */
  288. void RoomHandler()
  289.   {
  290.   int NewSize, i;
  291.   aRoom *TempTab;
  292.   extern char *WRITE_ANY;
  293.   printf("Current room size is %d\n", MAXROOMS);
  294.   NewSize = getUtilNumber("New size", 3, 65535);
  295.   if (NewSize == MAXROOMS) return ;
  296.   if (NewSize < MAXROOMS)
  297.     {
  298.     for (i = MAXROOMS-1; i >= NewSize; i--)
  299.     if (roomTab[i].rtflags.INUSE)
  300.       {
  301.       printf(
  302.       "A room called '%s' will be lost.\n", roomTab[i].rtname);
  303.       if (!getUYesNo("Do you still wish to contract the rooms"))
  304.       return;
  305.  
  306.       };
  307.     TempTab = (aRoom *) GetDynamic(sizeof roomBuf * NewSize);
  308.     for (i = 0; i < NewSize; i++)
  309.       {
  310.       getRoom(i);
  311.       movmem(&roomBuf, TempTab+i, sizeof roomBuf);
  312.       TempTab[i].msg = (theMessages *) GetDynamic(MSG_BULK);
  313.       movmem(roomBuf.msg, TempTab[i].msg, MSG_BULK);
  314.  
  315.       }
  316.     remakeRoomFl();
  317.     for (i = 0; i < NewSize; i++)
  318.       {
  319.       movmem(TempTab+i, &roomBuf, RB_SIZE);
  320.       movmem(TempTab[i].msg, roomBuf.msg, MSG_BULK);
  321.       putRoom(i);
  322.       DoFree(TempTab[i].msg);
  323.  
  324.       }
  325.     DoFree(TempTab);
  326.     LogGenChange(NewSize);
  327.  
  328.     }
  329.   else
  330.     {
  331.     roomTab = (rTable *) realloc(roomTab, sizeof *roomTab * NewSize);
  332.     setmem(&roomBuf, RB_SIZE, 0);   /* Zilch all but the pointers */
  333.     setmem(roomBuf.msg, MSG_BULK, 0);
  334.     for (i = MAXROOMS; i <= NewSize; i++)
  335.       {
  336.       zero_struct(roomTab[i]);
  337.       RoomSys(i);
  338.       putRoom(i);
  339.  
  340.       }
  341.     LogGenChange(NewSize);
  342.  
  343.     }
  344.   MAXROOMS = NewSize;
  345.   printf("Please remember to changes MAXROOMS to %d\n\n", MAXROOMS);
  346.  
  347.   }
  348. /*
  349. * LogGenChange()
  350. *
  351. * This function will change the generation array of the log.  This needs to
  352. * be done when the number of rooms in the system changes.
  353. */
  354. void LogGenChange(NewSize)
  355. int NewSize;
  356.   {
  357.   int i, oldSize;
  358.   logBuffer *NewLogs;
  359.   extern char *WRITE_ANY;
  360.   SYS_FILE tempname;
  361.   NewLogs = (logBuffer *) GetDynamic(sizeof logBuf * cfg.MAXLOGTAB);
  362.   for (i = 0; i < cfg.MAXLOGTAB; i++)
  363.     {
  364.     getLog(&logBuf, i);
  365.     if (logBuf.lbflags.L_INUSE) printf("reading %s\n", logBuf.lbname);
  366.     movmem(&logBuf, NewLogs + i, LB_SIZE);
  367.     NewLogs[i].lbgen = (AN_UNSIGNED *) GetDynamic(
  368.     NewSize * sizeof (AN_UNSIGNED));
  369.     setmem(NewLogs[i].lbgen, NewSize * sizeof (AN_UNSIGNED), 0);
  370.     movmem(logBuf.lbgen, NewLogs[i].lbgen,
  371.     minimum(NewSize, MAXROOMS) * sizeof (AN_UNSIGNED));
  372.     NewLogs[i].lbMail = (theMessages *) GetDynamic(MAIL_BULK);
  373.     movmem(logBuf.lbMail, NewLogs[i].lbMail, MAIL_BULK);
  374.  
  375.     }
  376.   oldSize = MAXROOMS;
  377.   MAXROOMS = NewSize;
  378.   fclose(logfl);
  379.   makeSysName(tempname, "ctdllog.sys", &cfg.logArea);
  380.   unlink(tempname);
  381.   if ((logfl = fopen(tempname, WRITE_ANY)) == NULL)
  382.     {
  383.     crashout("Couldn't reopen log file!  (Return to your backups!)");
  384.  
  385.     }
  386.   DoFree(logBuf.lbgen);
  387.   logBuf.lbgen = (AN_UNSIGNED *) GetDynamic(GEN_BULK);
  388.   for (i = 0; i < cfg.MAXLOGTAB; i++)
  389.     {
  390.     movmem(NewLogs + i, &logBuf, LB_SIZE);
  391.     movmem(NewLogs[i].lbgen, logBuf.lbgen, NewSize * sizeof (AN_UNSIGNED));
  392.     movmem(NewLogs[i].lbMail, logBuf.lbMail, MAIL_BULK);
  393.     DoFree(NewLogs[i].lbgen);
  394.     DoFree(NewLogs[i].lbMail);
  395.     putLog(&logBuf, i);
  396.     if (logBuf.lbflags.L_INUSE)
  397.     printf("writing %s\n", logBuf.lbname);
  398.  
  399.     }
  400.   DoFree(NewLogs);
  401.   fclose(logfl);
  402.   openFile(tempname, &logfl);
  403.   MAXROOMS = oldSize;
  404.  
  405.   }
  406. /*
  407. * MsgHandler()
  408. *
  409. * This function handles changes to MSGSPERRM.
  410. */
  411. void MsgHandler()
  412.   {
  413.   int NewSize, i, r1, r2, newBulk;
  414.   aRoom *TempRooms;
  415.   printf("Current messages per room is %d\n", MSGSPERRM);
  416.   NewSize = getUtilNumber("New size", 0, 65535);
  417.   newBulk = sizeof (theMessages) * NewSize;
  418.   if (NewSize == MSGSPERRM) return ;
  419.   TempRooms = (aRoom *) GetDynamic(sizeof roomBuf * MAXROOMS);
  420.   for (i = 0; i < MAXROOMS; i++)
  421.     {
  422.     getRoom(i);
  423.     movmem(&roomBuf, TempRooms+i, RB_SIZE);
  424.     TempRooms[i].msg = (theMessages *) GetDynamic(newBulk);
  425.     setmem(TempRooms[i].msg, newBulk, 0);
  426.     for (r1 = MSGSPERRM - 1, r2 = NewSize - 1;
  427.     r1 != -1 && r2 != -1; r1--, r2--)
  428.       {
  429.       TempRooms[i].msg[r2].rbmsgNo  = roomBuf.msg[r1].rbmsgNo;
  430.       TempRooms[i].msg[r2].rbmsgLoc = roomBuf.msg[r1].rbmsgLoc;
  431.  
  432.       }
  433.  
  434.     }
  435.   remakeRoomFl();
  436.   killRoomBuf(&roomBuf);
  437.   MSGSPERRM = NewSize;
  438.   for (i = 0; i < MAXROOMS; i++)
  439.     {
  440.     movmem(TempRooms+i, &roomBuf, RB_SIZE);
  441.     roomBuf.msg = TempRooms[i].msg;     /* Cheat */
  442.     putRoom(i);
  443.     DoFree(TempRooms[i].msg);
  444.  
  445.     }
  446.   DoFree(TempRooms);
  447.   initRoomBuf(&roomBuf);
  448.   printf("Please remember to change MSG-SLOTS to %d\n\n", MSGSPERRM);
  449.  
  450.   }
  451. /*
  452. * remakeRoomFl()
  453. *
  454. * This function handles killing and re-opening the room file.
  455. */
  456. void remakeRoomFl()
  457.   {
  458.   SYS_FILE tempname;
  459.   extern char *W_R_ANY;
  460.   fclose(roomfl);
  461.   makeSysName(tempname, "ctdlroom.sys", &cfg.roomArea);
  462.   unlink(tempname);
  463.   if ((roomfl = fopen(tempname, W_R_ANY)) == NULL)
  464.     {
  465.     crashout("Couldn't reopen room file!  (Return to your backups!)");
  466.  
  467.     }
  468.  
  469.   }
  470. /*
  471. * remakeLogFl()
  472. *
  473. * This function handles killing and re-opening the log file.
  474. */
  475. void remakeLogFl()
  476.   {
  477.   SYS_FILE tempname;
  478.   extern char *W_R_ANY;
  479.   fclose(logfl);
  480.   makeSysName(tempname, "ctdllog.sys", &cfg.logArea);
  481.   unlink(tempname);
  482.   if ((logfl = fopen(tempname, W_R_ANY)) == NULL)
  483.     {
  484.     crashout("Couldn't reopen log file!  (Return to your backups!)");
  485.  
  486.     }
  487.  
  488.   }
  489. /*
  490. * remakeNetFl()
  491. *
  492. * This function handles killing and re-opening the net file.
  493. */
  494. void remakeNetFl()
  495.   {
  496.   SYS_FILE tempname;
  497.   extern char *W_R_ANY;
  498.   fclose(netfl);
  499.   makeSysName(tempname, "ctdlnet.sys", &cfg.netArea);
  500.   unlink(tempname);
  501.   if ((netfl = fopen(tempname, W_R_ANY)) == NULL)
  502.     {
  503.     crashout("Couldn't reopen net file!  (Return to your backups!)");
  504.  
  505.     }
  506.  
  507.   }
  508. /*
  509. * MailHandler()
  510. *
  511. * This function handles the contraction/expansion of MAILSLOTS.
  512. */
  513. void MailHandler()
  514.   {
  515.   int NewSize, i, old, r1, r2;
  516.   logBuffer *NewLog;
  517.   old = MAILSLOTS;
  518.   printf("Current messages per user in Mail is %d\n", MAILSLOTS);
  519.   NewSize = getUtilNumber("New size", 0, 65535);
  520.   if (NewSize == MAILSLOTS) return ;
  521.   NewLog = (logBuffer *) GetDynamic(sizeof logBuf * cfg.MAXLOGTAB);
  522.   for (i = 0; i < cfg.MAXLOGTAB; i++)
  523.     {
  524.     getLog(&logBuf, i);
  525.     movmem(&logBuf, NewLog + i, LB_SIZE);
  526.     MAILSLOTS = NewSize;
  527.     initLogBuf(&NewLog[i]);
  528.     MAILSLOTS = old;
  529.     for (r1 = MAILSLOTS-1, r2 = NewSize-1;
  530.     r1 != -1 && r2 != -1; r1--, r2--)
  531.       {
  532.       NewLog[i].lbMail[r2].rbmsgNo  = logBuf.lbMail[r1].rbmsgNo;
  533.       NewLog[i].lbMail[r2].rbmsgLoc = logBuf.lbMail[r1].rbmsgLoc;
  534.  
  535.       }
  536.     movmem(logBuf.lbgen, NewLog[i].lbgen, GEN_BULK);
  537.  
  538.     }
  539.   remakeLogFl();
  540.   killLogBuf(&logBuf);
  541.   MAILSLOTS = NewSize;
  542.   for (i = 0; i < cfg.MAXLOGTAB; i++)
  543.     {
  544.     movmem(NewLog + i, &logBuf, sizeof logBuf);
  545.     putLog(&logBuf, i);
  546.     killLogBuf(&logBuf);  /* this looks strange but works */
  547.  
  548.     }
  549.   DoFree(NewLog);
  550.   initLogBuf(&logBuf);
  551.   killRoomBuf(&roomBuf);
  552.   initRoomBuf(&roomBuf);
  553.   printf("Please remember to change your MAIL-SLOTS parameter to %d\n\n",
  554.   MAILSLOTS);
  555.  
  556.   }
  557. #define check(x) if (test) printf("%c\n", x);
  558. /*
  559. * SharedHandler()
  560. *
  561. * This function changes the number of shared rooms/system.
  562. */
  563. void SharedHandler()
  564.   {
  565.   int NewSize, i, old;
  566.   NetBuffer *NewNet;
  567.   char test;
  568.   old = SHARED_ROOMS;
  569.   printf("Current shared rooms/system is %d\n", SHARED_ROOMS);
  570.   NewSize = getUtilNumber("new shared rooms/system", 0, 65535);
  571.   if (NewSize == SHARED_ROOMS) return ;
  572.   if (cfg.netSize == 0)
  573.     {
  574.     SHARED_ROOMS = NewSize;
  575.     return ;
  576.  
  577.     }
  578.   if (NewSize < SHARED_ROOMS)
  579.   if (!getUYesNo("That value could result in losing shared rooms.  Continue"))
  580.   return;
  581.   test=FALSE;
  582.   NewNet = (NetBuffer *) GetDynamic(sizeof netBuf * cfg.netSize);
  583.   for (i = 0; i < cfg.netSize; i++)
  584.     {
  585.     check('a');
  586.     getNet(i, &netBuf);
  587.     check('b');
  588.     SHARED_ROOMS = NewSize;
  589.     initNetBuf(&NewNet[i]);
  590.     check('c');
  591.     movmem(&netBuf, NewNet + i, NB_SIZE);
  592.     check('d');
  593.     setmem(NewNet[i].netRooms, SR_BULK, 0);     /* 0 it */
  594.     check('e');
  595.     SHARED_ROOMS = old;
  596.     check('f');
  597.     movmem(netBuf.netRooms, NewNet[i].netRooms,
  598.     minimum(SR_BULK, (NewSize * (sizeof (SharedRoom)))));
  599.     check('g');
  600.  
  601.     }
  602.   /*test=TRUE;*/
  603.   check('1');
  604.   remakeNetFl();
  605.   killNetBuf(&netBuf);
  606.   SHARED_ROOMS = NewSize;
  607.   for (i = 0; i < cfg.netSize; i++)
  608.     {
  609.     check('z');
  610.     movmem(NewNet + i, &netBuf, sizeof netBuf);
  611.     check('y');
  612.     DoFree(netTab[i].netTRooms);
  613.     netTab[i].netTRooms = GetDynamic(SR_BULK);
  614.     check('x');
  615.     putNet(i, &netBuf);
  616.     check('w');
  617.     DoFree(netBuf.netRooms);
  618.     check('v');
  619.     check('u');
  620.  
  621.     }
  622.   check('2');
  623.   DoFree(NewNet);
  624.   initNetBuf(&netBuf);
  625.   printf("Please change your SHARED-ROOMS parameter to %d.\n\n",
  626.   SHARED_ROOMS);
  627.   check('3');
  628.  
  629.   }
  630.